package negocio;

import datos.Domicilio;
import datos.Permiso;
import datos.TipoDocumento;
import datos.Usuario;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import javax.persistence.PersistenceContext;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

/**
 *
 * @author Ing. Monica Merlo, Ing. Agustin  Fernandez
 */
@Stateless
public class GestorUsuarioBean implements GestorUsuarioRemote, GestorUsuarioLocal {
    static Logger logger = Logger.getLogger(GestorUsuarioBean.class);
    public static void log4j(Exception e){
        URL url = GestorUsuarioBean.class.getResource("/configuracion/log4j.properties");
        PropertyConfigurator.configure(url);
        logger.error(e);
    }
    @PersistenceContext
    private EntityManager em;

    /***
     * Retorna todas las instancias Usuario
     * @return lista con todas las instancias de Usuario
     * y null en caso contrario
     * interfaz local
     */
    public List usuarios() {
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.findAll");
        return q.getResultList();

        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Retorna todas las instancias Usuario
     * @return lista con todas las instancias de Usuario
     * y null en caso contrario
     * interfaz remota
     */
    public List usuariosRemote() {
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.findAll");
        return q.getResultList();

        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }


    /***
     * Realiza una busqueda de las instancias de tipo Usuario
     * que coincidan con el criterio de busqueda.
     * @param nombre
     * @param apellido
     * @param usuario
     * @return lista de todos aquellas instancias Usuario con nombre como "nombre",
     * apellido como "apellido", usuario como "usuario" ordenados por usuario". Null en caso contrario
     * interfaz local
     */
    public List filtrarUsuarios(String nombre, String apellido, String usuario){
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.filtrarUsuarios");
            q.setParameter("nombre", nombre.toUpperCase());
            q.setParameter("apellido", apellido.toUpperCase());
            q.setParameter("usuario", usuario);
        return q.getResultList();

        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Realiza una busqueda de las instancias de tipo Usuario
     * que coincidan con el criterio de busqueda.
     * @param nombre
     * @param apellido
     * @param usuario
     * @return lista de todos aquellas instancias Usuario con nombre como "nombre",
     * apellido como "apellido", usuario como "usuario" ordenados por usuario". Null en caso contrario
     * interfaz remota
     */
    public List filtrarUsuariosRemote(String nombre, String apellido, String usuario){
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.filtrarUsuarios");
            q.setParameter("nombre", nombre.toUpperCase());
            q.setParameter("apellido", apellido.toUpperCase());
            q.setParameter("usuario", usuario);
        return q.getResultList();

        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Retorna una instancia TipoDocumento que su nombre
     * coincida con el valor del parametro nombre.
     * @param nombre
     * @return instancia TipoDocumento con tipo = nombre y null en caso contrario
     * interfaz local
     */
    public TipoDocumento encontrarTipoDocumento(String nombre){
        try{
            javax.persistence.Query q = em.createNamedQuery("TipoDocumento.findByTipo");
            q.setParameter("tipo", nombre);
            return (TipoDocumento)q.getSingleResult();

        }
        catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;}

    }

    /***
     * Retorna una instancia TipoDocumento que su nombre
     * coincida con el valor del parametro nombre.
     * @param nombre
     * @return instancia TipoDocumento con tipo = nombre y null en caso contrario
     * interfaz remota
     */
    public TipoDocumento encontrarTipoDocumentoRemote(String nombre){
        try{
            javax.persistence.Query q = em.createNamedQuery("TipoDocumento.findByTipo");
            q.setParameter("tipo", nombre);
            return (TipoDocumento)q.getSingleResult();

        }
        catch(Exception e){GestorUsuarioBean.log4j(e);
        return null;}

    }

    /***
     * Devuelve todos los nombres de las instancias de tipo Permiso
     * @return lista con todos los nombres ordenados de las instancias de Permiso
     * y null en caso contrario
     * interfaz local
     */
    public List<String> permisos(){
        try{
            javax.persistence.Query q = em.createNamedQuery("Permiso.encontrarNombreTodosPermisosDisponibles");
            return q.getResultList();

        }

        catch(Exception e){GestorUsuarioBean.log4j(e);
        return null;}
    }

    /***
     * Devuelve todos los nombres de las instancias de tipo Permiso
     * @return lista con todos los nombres ordenados de las instancias de Permiso
     * y null en caso contrario
     * interfaz remota
     */
    public List<String> permisosRemote(){
        try{
            javax.persistence.Query q = em.createNamedQuery("Permiso.encontrarNombreTodosPermisosDisponibles");
            return q.getResultList();

        }

        catch(Exception e){GestorUsuarioBean.log4j(e);
        return null;}
    }

    /***
     * Busca una instancia Permiso con nombre igual al valor del parametro nombrePermiso
     * @param nombrePermiso
     * @return instancia de Permiso con nombre = nombrePermiso
     * y null en caso contrario
     * interfaz local
     */
    public Permiso encontrarPermisoPorNombre(String nombrePermiso){
        try {
            javax.persistence.Query q = em.createNamedQuery("Permiso.findByNombre");
            q.setParameter("nombre", nombrePermiso);
            return (Permiso)q.getSingleResult();
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Busca una instancia Permiso con nombre igual al valor del parametro nombrePermiso
     * @param nombrePermiso
     * @return instancia de Permiso con nombre = nombrePermiso
     * y null en caso contrario
     * interfaz remota
     */
    public Permiso encontrarPermisoPorNombreRemote(String nombrePermiso){
        try {
            javax.persistence.Query q = em.createNamedQuery("Permiso.findByNombre");
            q.setParameter("nombre", nombrePermiso);
            return (Permiso)q.getSingleResult();
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Busca una instancia Usuario con ID igual al valor del parametro idUsuario
     * @param idUsuario
     * @return instancia Usuario con id = idUsuario
     * y null en caso contrario
     * interfaz local
     */
    public Usuario encontrarUsuarioPorId(int idUsuario){
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.findById");
            q.setParameter("id", idUsuario);
            return (Usuario)q.getSingleResult();
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Busca una instancia Usuario con ID igual al valor del parametro idUsuario
     * @param idUsuario
     * @return instancia Usuario con id = idUsuario
     * y null en caso contrario
     * interfaz remota
     */
    public Usuario encontrarUsuarioPorIdRemote(int idUsuario){
        try{
            javax.persistence.Query q = em.createNamedQuery("Usuario.findById");
            q.setParameter("id", idUsuario);
            return (Usuario)q.getSingleResult();
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Agrega una nueva instancia de tipo Usuario en la BD.
     * @param nombre
     * @param apellido
     * @param usuario
     * @param password
     * @param numeroDocumento
     * @param tipoDocumento
     * @param calle
     * @param numeroCalle
     * @param barrio
     * @param piso
     * @param depto
     * @param codPostal
     * @param idLocalidad
     * @param idPais
     * @param permisos
     * @return ID de la nueva instancia de Usuario si ésta ha sido persistida con exito en la base de datos
     * y -1 en caso contrario
     * interfaz local
     */
    public int agregarUsuario(String nombre, String apellido, String usuario, String password,
                              int numeroDocumento, String tipoDocumento, String calle, String numeroCalle,
                              String barrio, int piso, String depto, String codPostal, int idLocalidad, int idPais,
                              List<String> permisos){
        try {
            Usuario usu=new Usuario();
            usu.setApellido(apellido.toUpperCase());
            usu.setNombre(nombre.toUpperCase());
            usu.setNumeroDocumento(numeroDocumento);
            TipoDocumento td = encontrarTipoDocumento(tipoDocumento.toUpperCase());
            usu.setIdTipoDocumento(td);
            usu.setPassword(password);
            usu.setUsuario(usuario);
            Domicilio domUsu = new Domicilio();
            domUsu.setBarrio(barrio.toUpperCase());
            domUsu.setCalle(calle.toUpperCase());
            domUsu.setCodPostal(codPostal.toUpperCase());
            domUsu.setDepto(depto.toUpperCase());
            domUsu.setNumero(numeroCalle.toUpperCase());
            domUsu.setPiso(piso);
            datos.Localidad loc = em.find(datos.Localidad.class, idLocalidad);
            domUsu.setIdLocalidad(loc);
            datos.Pais pais = em.find(datos.Pais.class, idPais);
            domUsu.setIdPais(pais);
            persist(domUsu);
            usu.setIdDomicilio(domUsu);
            persist(usu);
            Permiso per;
            List<Permiso> lper=new ArrayList<Permiso>();
            for(String pnombre: permisos){
                per=this.encontrarPermisoPorNombre(pnombre);
                lper.add(per);
                List<Usuario> lusu=(List<Usuario>) per.getUsuarioCollection();
                lusu.add(usu);
                per.setUsuarioCollection(lusu);
                persist(per);
            }
            usu.setPermisoCollection(lper);
            persist(usu);

            em.flush();
            return usu.getId();

        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return -1;
        }
    }

    /***
     * Agrega una nueva instancia de tipo Usuario en la BD.
     * @param nombre
     * @param apellido
     * @param usuario
     * @param password
     * @param numeroDocumento
     * @param tipoDocumento
     * @param calle
     * @param numeroCalle
     * @param barrio
     * @param piso
     * @param depto
     * @param codPostal
     * @param idLocalidad
     * @param idPais
     * @param permisos
     * @return ID de la nueva instancia de Usuario si ésta ha sido persistida con exito en la base de datos
     * y -1 en caso contrario
     * interfaz remota
     */
    public int agregarUsuarioRemote(String nombre, String apellido, String usuario, String password,
                                    int numeroDocumento, String tipoDocumento, String calle, String numeroCalle,
                                    String barrio, int piso, String depto, String codPostal, int idLocalidad, int idPais,
                                    List<String> permisos){
        try {
            Usuario usu=new Usuario();
            usu.setApellido(apellido.toUpperCase());
            usu.setNombre(nombre.toUpperCase());
            usu.setNumeroDocumento(numeroDocumento);
            TipoDocumento td = encontrarTipoDocumento(tipoDocumento.toUpperCase());
            usu.setIdTipoDocumento(td);
            usu.setPassword(password);
            usu.setUsuario(usuario);
            Domicilio domUsu = new Domicilio();
            domUsu.setBarrio(barrio.toUpperCase());
            domUsu.setCalle(calle.toUpperCase());
            domUsu.setCodPostal(codPostal.toUpperCase());
            domUsu.setDepto(depto.toUpperCase());
            domUsu.setNumero(numeroCalle.toUpperCase());
            domUsu.setPiso(piso);
            datos.Localidad loc = em.find(datos.Localidad.class, idLocalidad);
            domUsu.setIdLocalidad(loc);
            datos.Pais pais = em.find(datos.Pais.class, idPais);
            domUsu.setIdPais(pais);
            persist(domUsu);
            usu.setIdDomicilio(domUsu);
            persist(usu);
            Permiso per;
            List<Permiso> lper=new ArrayList<Permiso>();
            for(String pnombre: permisos){
                per=this.encontrarPermisoPorNombre(pnombre);
                lper.add(per);
                List<Usuario> lusu=(List<Usuario>) per.getUsuarioCollection();
                lusu.add(usu);
                per.setUsuarioCollection(lusu);
                persist(per);
            }
            usu.setPermisoCollection(lper);
            persist(usu);

            em.flush();
            return usu.getId();

        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return -1;
        }
    }

    /***
     * Actualiza una instancia de tipo Usuario, previamente encontrada en la BD.
     * @param idUsuario
     * @param nombre
     * @param apellido
     * @param usuario
     * @param password
     * @param numeroDocumento
     * @param tipoDocumento
     * @param calle
     * @param numeroCalle
     * @param barrio
     * @param piso
     * @param depto
     * @param codPostal
     * @param idLocalidad
     * @param idPais
     * @param permisos
     * @return true si la instancia de Usuario ha sido modificada y persistida con exito en la base de datos
     * y false en caso contrario
     * interfaz local
     */
    public boolean modificarUsuario(int idUsuario, String nombre, String apellido, String usuario, String password,
                                    int numeroDocumento, String tipoDocumento, String calle, String numeroCalle,
                                    String barrio, int piso, String depto, String codPostal, int idLocalidad, int idPais,
                                    List<String> permisos){
        try {
            Usuario usu=em.find(Usuario.class, idUsuario);
            usu.setApellido(apellido.toUpperCase());
            usu.setNombre(nombre.toUpperCase());
            usu.setNumeroDocumento(numeroDocumento);
            TipoDocumento td = encontrarTipoDocumento(tipoDocumento.toUpperCase());
            usu.setIdTipoDocumento(td);
            usu.setPassword(password);
            usu.setUsuario(usuario);
            Domicilio domUsu = usu.getIdDomicilio();
            domUsu.setBarrio(barrio.toUpperCase());
            domUsu.setCalle(calle.toUpperCase());
            domUsu.setCodPostal(codPostal.toUpperCase());
            domUsu.setDepto(depto.toUpperCase());
            domUsu.setNumero(numeroCalle.toUpperCase());
            domUsu.setPiso(piso);
            datos.Localidad loc = em.find(datos.Localidad.class, idLocalidad);
            domUsu.setIdLocalidad(loc);
            datos.Pais pais = em.find(datos.Pais.class, idPais);
            domUsu.setIdPais(pais);
            persist(domUsu);
            usu.setIdDomicilio(domUsu);
            persist(usu);
            Permiso perAgregar;
            //Agrego los permisos a la relación many to many
            for(String pnombre: permisos){
                perAgregar=this.encontrarPermisoPorNombre(pnombre);
                    if(!usu.getPermisoCollection().contains(perAgregar)){
                         usu.getPermisoCollection().add(perAgregar);
                         perAgregar.getUsuarioCollection().add(usu);
                         persist(perAgregar);
                    }
            }
            //Quito los permisos que no esten en la relación many to many
            java.util.Iterator iterador = usu.getPermisoCollection().iterator();
            while(iterador.hasNext()){
                Permiso per = (Permiso) iterador.next();
                if(!permisos.contains(per.getNombre())){
                    iterador.remove();
                    per.getUsuarioCollection().remove(usu);
                }
            }
            persist(usu);
            em.flush();
            return true;
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return false;
        }
    }

    /***
     * Actualiza una instancia de tipo Usuario, previamente encontrada en la BD.
     * @param idUsuario
     * @param nombre
     * @param apellido
     * @param usuario
     * @param password
     * @param numeroDocumento
     * @param tipoDocumento
     * @param calle
     * @param numeroCalle
     * @param barrio
     * @param piso
     * @param depto
     * @param codPostal
     * @param idLocalidad
     * @param idPais
     * @param permisos
     * @return true si la instancia de Usuario ha sido modificada y persistida con exito en la base de datos
     * y false en caso contrario
     * interfaz remota
     */
    public boolean modificarUsuarioRemote(int idUsuario, String nombre, String apellido, String usuario, String password,
                                    int numeroDocumento, String tipoDocumento, String calle, String numeroCalle,
                                    String barrio, int piso, String depto, String codPostal, int idLocalidad, int idPais,
                                    List<String> permisos){
        try {
            Usuario usu=em.find(Usuario.class, idUsuario);
            usu.setApellido(apellido.toUpperCase());
            usu.setNombre(nombre.toUpperCase());
            usu.setNumeroDocumento(numeroDocumento);
            TipoDocumento td = encontrarTipoDocumento(tipoDocumento.toUpperCase());
            usu.setIdTipoDocumento(td);
            usu.setPassword(password);
            usu.setUsuario(usuario);
            Domicilio domUsu = usu.getIdDomicilio();
            domUsu.setBarrio(barrio.toUpperCase());
            domUsu.setCalle(calle.toUpperCase());
            domUsu.setCodPostal(codPostal.toUpperCase());
            domUsu.setDepto(depto.toUpperCase());
            domUsu.setNumero(numeroCalle.toUpperCase());
            domUsu.setPiso(piso);
            datos.Localidad loc = em.find(datos.Localidad.class, idLocalidad);
            domUsu.setIdLocalidad(loc);
            datos.Pais pais = em.find(datos.Pais.class, idPais);
            domUsu.setIdPais(pais);
            persist(domUsu);
            usu.setIdDomicilio(domUsu);
            persist(usu);
            Permiso perAgregar;
            //Agrego los permisos a la relación many to many
            for(String pnombre: permisos){
                perAgregar=this.encontrarPermisoPorNombre(pnombre);
                    if(!usu.getPermisoCollection().contains(perAgregar)){
                         usu.getPermisoCollection().add(perAgregar);
                         perAgregar.getUsuarioCollection().add(usu);
                         persist(perAgregar);
                    }
            }
            //Quito los permisos que no esten en la relación many to many
            java.util.Iterator iterador = usu.getPermisoCollection().iterator();
            while(iterador.hasNext()){
                Permiso per = (Permiso) iterador.next();
                if(!permisos.contains(per.getNombre())){
                    iterador.remove();
                    per.getUsuarioCollection().remove(usu);
                }  
            }
            persist(usu);
            em.flush();
            return true;
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return false;
        }
    }


    /***
     * Modifica la clave del usuario, cuando este lo elige.
     * @param usuario
     * @param passwordNuevo
     * @return true si se ha actualizado la clave correctamente y false en caso contrario
     */
    public boolean modificarClaveRemote (String usuario, String passwordNuevo){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", usuario);
            Usuario usu = (Usuario) q.getSingleResult();
            if (usu != null) {
                usu.setPassword(passwordNuevo);
                persist(usu);
                em.flush();
                return true;
            }else return false;
            
           
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return false;
        }
        
    }


    /***
     * Modifica la clave del usuario, cuando este lo elige.
     * @param usuario
     * @param passwordNuevo
     * @return true si se ha actualizado la clave correctamente y false en caso contrario
     */
     public boolean modificarClave (String usuario, String passwordNuevo){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", usuario);
            Usuario usu = (Usuario) q.getSingleResult();
            if (usu != null) {
                usu.setPassword(passwordNuevo);
                persist(usu);
                em.flush();
                return true;
            }else return false;
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return false;
        }

    }


    /***
     * Remueve una instancia de tipo Usuario de la BD.
     * @param idUsuario
     * @return true si la instancia de Usuario ha sido encontrada por su idUsuario y
     * removida, junto con sus relaciones a clases, con exito de la base de datos
     * y false en caso contrario
     * interfaz local
     */
    public boolean eliminarUsuario(int idUsuario){
        try {
            Usuario usu = em.find(Usuario.class, idUsuario);
            em.remove(usu.getIdDomicilio());
            em.remove(usu);
            return true;
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return false;
        }
    }

    /***
     * Remueve una instancia de tipo Usuario de la BD.
     * @param idUsuario
     * @return true si la instancia de Usuario ha sido encontrada por su idUsuario y
     * removida, junto con sus relaciones a clases, con exito de la base de datos
     * y false en caso contrario
     * interfaz remota
     */
    public boolean eliminarUsuarioRemote(int idUsuario){
        try {
            Usuario usu = em.find(Usuario.class, idUsuario);
            em.remove(usu.getIdDomicilio());
            em.remove(usu);
            return true;
        } catch (Exception e) {
            GestorUsuarioBean.log4j(e);
            return false;
        }
    }

    /***
     * Método que devuelve el skin seleccionado por el usuario
     * @param nombreUsuario El nombre del usuario
     * @return devuelve el skin seleccionado por el usuario
     */
    public String skinSeleccionado(String nombreUsuario){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.encontrarSkinSeleccionado");
            q.setParameter("nombreUsuario", nombreUsuario);
            String skin = (String) q.getSingleResult();
            return skin;
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Método que devuelve el skin seleccionado por el usuario
     * @param nombreUsuario El nombre del usuario
     * @return devuelve el skin seleccionado por el usuario
     */
    public String skinSeleccionadoRemote(String nombreUsuario){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.encontrarSkinSeleccionado");
            q.setParameter("nombreUsuario", nombreUsuario);
            String skin = (String) q.getSingleResult();
            return skin;
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return null;
        }
    }

    /***
     * Modifica el skin del usuario, cuando este lo elige.
     * @param usuario el usuario que cambia su skin
     * @param skinNuevo el nuevo skin elegido por el usuario
     * @return true si se ha actualizado el skin correctamente y false en caso contrario
     */
     public boolean modificarSkinSeleccionado (String usuario, String skinNuevo){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", usuario);
            Usuario usu = (Usuario) q.getSingleResult();
            if (usu != null) {
                usu.setSkin(skinNuevo);
                persist(usu);
                em.flush();
                return true;
            }else return false;
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return false;
        }

    }

    /***
     * Modifica el skin del usuario, cuando este lo elige.
     * @param usuario el usuario que cambia su skin
     * @param skinNuevo el nuevo skin elegido por el usuario
     * @return true si se ha actualizado el skin correctamente y false en caso contrario
     */
     public boolean modificarSkinSeleccionadoRemote (String usuario, String skinNuevo){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", usuario);
            Usuario usu = (Usuario) q.getSingleResult();
            if (usu != null) {
                usu.setSkin(skinNuevo);
                persist(usu);
                em.flush();
                return true;
            }else return false;
        }catch(Exception e){
            GestorUsuarioBean.log4j(e);
            return false;
        }

    }

    /***
     * Valida la existencia de alguna instancia de tipo Usuario, con
     * nombre igual al valor del parametro nombreUsuario.
     * @param nombreUsuario
     * @return true si existe alguna instancia de Usuario con usuario = nombreUsuario
     * y false en caso contrario
     * interfaz local
     */
    public boolean existeNombreUsuario(String nombreUsuario){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", nombreUsuario);
            if (q.getSingleResult() != null) {
                return true;
            } else {
                return false;
            }
        } catch (NoResultException ne) {
            GestorUsuarioBean.log4j(ne);
            return false;
        } catch (NonUniqueResultException nue) {
            GestorUsuarioBean.log4j(nue);
            return true;
        } catch (IllegalStateException ie) {
            GestorUsuarioBean.log4j(ie);
            return true;
        }
    }

    /***
     * Valida la existencia de alguna instancia de tipo Usuario, con
     * nombre igual al valor del parametro nombreUsuario.
     * @param nombreUsuario
     * @return true si existe alguna instancia de Usuario con usuario = nombreUsuario
     * y false en caso contrario
     * interfaz remota
     */
    public boolean existeNombreUsuarioRemote(String nombreUsuario){
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuario");
            q.setParameter("usuario", nombreUsuario);
            if (q.getSingleResult() != null) {
                return true;
            } else {
                return false;
            }
        } catch (NoResultException ne) {
            GestorUsuarioBean.log4j(ne);
            return false;
        } catch (NonUniqueResultException nue) {
            GestorUsuarioBean.log4j(nue);
            return true;
        } catch (IllegalStateException ie) {
            GestorUsuarioBean.log4j(ie);
            return true;
        }
    }

    /***
     * Valida que no exista una instancia de tipo Usuario, cuyo nombre coincida
     * con el nuevo valor del parametro usuario.
     * @param usuario
     * @param id
     * @return true si existe alguna instancia Usuario con usuario = "usuario"
     * y id <> "id". False en caso contrario
     * interfaz remota
     */
    public boolean existeNombreUsuarioModificarRemote(String usuario, int id) {
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuarioModificar");
            q.setParameter("usuario", usuario);
            q.setParameter("id", id);
            if (q.getSingleResult() != null) {
                return true;
            } else {
                return false;
            }
        } catch (NoResultException ne) {
            GestorUsuarioBean.log4j(ne);
            return false;
        } catch (NonUniqueResultException nue) {
            GestorUsuarioBean.log4j(nue);
            return true;
        } catch (IllegalStateException ie) {
            GestorUsuarioBean.log4j(ie);
            return true;
        }
    }

    /***

     * Valida que no exista una instancia de tipo Usuario, cuyo nombre coincida
     * con el nuevo valor del parametro usuario.
     * @param usuario
     * @param id
     * @return true si existe alguna instancia Usuario con usuario = "usuario"
     * y id <> "id". False en caso contrario
     * interfaz local
     */
    public boolean existeNombreUsuarioModificar(String usuario, int id) {
        try {
            javax.persistence.Query q = em.createNamedQuery("Usuario.findByUsuarioModificar");
            q.setParameter("usuario", usuario);
            q.setParameter("id", id);
            if (q.getSingleResult() != null) {
                return true;
            } else {
                return false;
            }
        } catch (NoResultException ne) {
            GestorUsuarioBean.log4j(ne);
            return false;
        } catch (NonUniqueResultException nue) {
            GestorUsuarioBean.log4j(nue);
            return true;
        } catch (IllegalStateException ie) {
            GestorUsuarioBean.log4j(ie);
            return true;
        }
    }


    /***
     * 
     * @param usuario
     * @param id
     * @param password
     * @return
     */
    public boolean validarClaveActualUsuarioRemote (String usuario,int id, String clave){
       try{
           javax.persistence.Query q = em.createNamedQuery("Usuario.findClaveActual");
           q.setParameter("usuario", usuario);
           q.setParameter("id", id);
           q.setParameter("password", clave);
           if (q.getSingleResult() !=null){
               return true;
           }else{
               return false;
           }
       } catch(Exception e){
           GestorUsuarioBean.log4j(e);
           return false;
       }
    }


    /***
     * 
     * @param usuario
     * @param id
     * @param password
     * @return
     */
    public boolean validarClaveActualUsuario (String usuario, int id, String clave){
       try{
           javax.persistence.Query q = em.createNamedQuery("Usuario.findClaveActual");
           q.setParameter("usuario", usuario);
           q.setParameter("id", id);
           q.setParameter("password", clave);
           if (q.getSingleResult() !=null){
               return true;
           }else{
               return false;
           }
       } catch(Exception e){
           GestorUsuarioBean.log4j(e);
           return false;
       }
    }

    /***
     * 
     * @param object
     */
    public void persist(Object object) {
        em.persist(object);
    }


    
 
}
